package com.solution.admin.product.service.impl;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.solution.admin.product.constants.ProductConstants;
import com.solution.admin.product.dao.ProductSpecDao;
import com.solution.admin.product.entity.ProductSpecEntity;
import com.solution.admin.product.service.ProductSpecService;
import com.solution.common.dao.BaseDao;
import com.solution.common.exception.BizException;
import com.solution.common.page.PageBean;
import com.solution.common.page.PageParam;
import com.solution.common.service.impl.BaseServiceImpl;

/**
 * 商品规格service实现层
 * @author lilp
 * @date 2017-08-29 14:31:56
 */
@Service
public class ProductSpecServiceImpl extends BaseServiceImpl<ProductSpecEntity> implements ProductSpecService {

	/**
	 * 商品规格接口
	 */
	@Autowired
	private ProductSpecDao productSpecDao;

	protected BaseDao<ProductSpecEntity> getDao() {
		return this.productSpecDao;
	}

	/**
	 * 保存商品规格
	 * @param productSpecEntity 商品规格实体
	 * @return Long 添加成功商品规格的ID
	 * @author lilp
	 * @date 2017-08-29 14:31:56
	 */
	public long saveProductSpec(ProductSpecEntity productSpecEntity) {
		return productSpecDao.saveProductSpec(productSpecEntity);
	}

	/**
	 * 分页查询商品规格
	 * @param pageParam 分页参数
	 * @param paramMap 查询参数
	 * @return PageBean 分页参数和分页数据
	 * @author lilp
	 * @date 2017-08-29 14:31:56
	 */
	@Override
	public PageBean listProductSpecPage(PageParam pageParam, Map<String, Object> paramMap) {
		return productSpecDao.listProductSpecPage(pageParam, paramMap);
	}
	
	/**
	 * 根据ID查询用户信息
	 * @param id 用户id
	 * @return productSpecEntity 用户对象
	 * @author lilp
	 * @date 2017-08-29 14:31:56
	 */
	public ProductSpecEntity getProductSpecById(Long id) {
		return productSpecDao.getById(id.longValue());
	}

	/**
	 * 更新用户
	 * @param productSpecEntity 用户实体
	 * @return Long 更新是否成功，>1代表更新成功
	 * @author lilp
	 * @date 2017-08-29 14:31:56
	 */
	@Override
	@Transactional(rollbackFor=Exception.class)
	public int updateProductSpec(String specName, List<ProductSpecEntity> pseList) {
		try {
			// 查询已存在的规格详情
			Map<String, Object> param = new HashMap<String, Object>();
			param.put("specName", specName);
			List<ProductSpecEntity> specList = productSpecDao.listBy(param);
			Map<Long, ProductSpecEntity> specMap = new HashMap<Long, ProductSpecEntity>();
			if(specList != null && specList.size() > 0){
				for (ProductSpecEntity spec : specList) {
					specMap.put(spec.getId(), spec);
				}
			}
			// 新增的规格项值
			List<ProductSpecEntity> insertList = new ArrayList<ProductSpecEntity>();
			List<ProductSpecEntity> deleteList = new ArrayList<ProductSpecEntity>();
			if(pseList != null && pseList.size() > 0){
				for (ProductSpecEntity spec : pseList) {
					if(specMap.containsKey(spec.getId())){
						ProductSpecEntity tmpSpec = specMap.get(spec.getId());
						tmpSpec.setSpecName(specName);
						tmpSpec.setSpecValue(spec.getSpecValue());
						tmpSpec.setSpecPrice(spec.getSpecPrice());
						tmpSpec.setStatus(spec.getStatus());
						tmpSpec.setSortNo(pseList.indexOf(spec));
						tmpSpec.setModifier(spec.getModifier());
						productSpecDao.update(tmpSpec);
						specMap.remove(spec.getId());
					}else{
						spec.setSpecName(specName);
						spec.setSortNo(pseList.indexOf(spec));
						insertList.add(spec);
					}
				}
			}
			// 待删除列表
			for (Map.Entry<Long, ProductSpecEntity> entry: specMap.entrySet()) {
				deleteList.add(entry.getValue());
			}
			
			// 重新插入商品规格
			if(insertList.size() > 0){
				productSpecDao.batchInsert(insertList);
			}
			// 删除列表上移除的商品规格值
			if(deleteList.size() > 0){
				productSpecDao.batchUpdateProductSpecStatus(deleteList);
			}
		} catch (Exception e) {
			e.printStackTrace();
			throw new BizException("修改商品规格项失败");
		}
		return 1;
	}
	
	/**
	 * 根据条件查询商品规格
	 * @param param
	 * @return 数据列表
	 * @author lilp
	 * @date 2017-08-29 14:31:56
	 */
	@Override
	public List<ProductSpecEntity> listProductSpec( Map<String, Object> param){
		return  productSpecDao.listProductSpec(param);
	}
	
	/**
	 * 删除商品规格
	 * @param 
	 * @return int 返回删除记录条数
	 * @author lilp
	 * @date 2017-08-29 14:31:56
	 */
	public int deleteProductSpecById(long id){
		return  productSpecDao.deleteById(id);
	}
	
	
	/**
	 * 删除一组商品规格配置
	 * @param param
	 * @return
	 */
	public int deleteProductSpec(Map<String, Object> param){
		return productSpecDao.deleteProductSpec(param);
	}
	
	/**
	 * 修改商品规格排序值
	 * @param specName
	 * @param id
	 * @param direction
	 * @return
	 */
	public int updateProductSpecSort(String specName, String id, String direction){
		// 查询商品规格列表
		Map<String, Object> param = new HashMap<String,Object>();
		param.put("specName", specName);
		List<ProductSpecEntity> pseList = productSpecDao.listBy(param);
		
		List<ProductSpecEntity>  tmpList = new ArrayList<ProductSpecEntity>();
		// 确定序列更新到数据库
		if(ProductConstants.SORT_DIRECTION.UP.getId().equals(direction)){
			// 上移
			for (ProductSpecEntity pse : pseList) {
				if(pse.getId().longValue() == Long.parseLong(id)){
					tmpList.add((pseList.indexOf(pse)-1)<0?0:(pseList.indexOf(pse)-1),pse);
				}else{
					tmpList.add(pse);
				}
			}
		}else if (ProductConstants.SORT_DIRECTION.DOWN.getId().equals(direction)){
			// 下移
			int toInsertPosition = 0;
			ProductSpecEntity toInsertPse = null;
			for (ProductSpecEntity pse : pseList) {
				// 遇到要置顶的元素，插入到第一位置
				if(pse.getId().longValue() == Long.parseLong(id)){
					toInsertPosition = pseList.indexOf(pse)+1;
					toInsertPse = pse;
					continue;
				}else{
					tmpList.add(pse);
				}
			}
			if(toInsertPse != null){
				tmpList.add(toInsertPosition, toInsertPse);
			}
		}else{
			// 置顶操作
			for (ProductSpecEntity pse : pseList) {
				// 遇到要置顶的元素，插入到第一位置
				if(pse.getId().longValue() == Long.parseLong(id)){
					tmpList.add(0,pse);
				}else{
					tmpList.add(pse);
				}
			}
		}
		int resultSum = 0;
		if(tmpList != null && tmpList.size() > 0){
			for (ProductSpecEntity pse : tmpList) {
				pse.setSortNo(tmpList.indexOf(pse));
				int result = productSpecDao.updateProductSpecSort(pse);
				resultSum += result;
			}
		}
		return resultSum;
	}
	
	/**
     * 根据商品分类ID获取规格项集合
     * 
     * @Title: listProductSpecByCategoryId
     * @Description:(描述)
     * @param productCategoryId
     * @return List<ProductSpecEntity>
     * @author xu_cc
     * @throws Exception
     *             exception
     * @Date 创建时间：2017年10月16日 上午11:42:42
     */
    public List<ProductSpecEntity> listProductSpecByCategoryId(String productCategoryId) {
        return productSpecDao.listProductSpecByCategoryId(productCategoryId);
    }
}
